ASP NET - Limite de Variáveis
Porque o limite de variáveis é relevante ?
Se você trabalha com outras linguagens sabe quanto é importante escolher a variável correta
para armazenar a informação que deseja.
Caso escolha o tipo errado pode dar, de cara, erro de compilação. Se sua ferramenta trata essa
'conversão' automaticamente para você saiba que isto tem um custo e está sujeito a interpretações
e arredondamentos fazendo com que o resultado obtido não seja o esperado. Por exemplo, 5 + 5
em asp net é 10 mas em javscript é 55, logicamente, dependendo do tipo da variável e da situação
que a operação está sendo empregrada
O .NET ( bem como o ASP.NET ) utiliza variáveis fortemente tipadas, ou seja, armazenam um tipo
específico ou uma categoria definida de dado. Por exemplo, se a variável é inteira e você fizer
variavel inteira = 12 / 5 o resultado será 2 e mais nada, o resto vai pra cacha prego.
Se você conhecem bem SQL sabe que não deve usar variáveis tipo float para armazenar dinheiro.
Isso se dá ao fato que as variáveis são feitas para armazenar quantias absurdas como distancias
estrelares e um erro e um metro não é de longe significativo. Portanto se quiser armazenar dinheiro
em variáveis e quiser que os centavos batam você precisa usar o tipo decimal no SQL e ainda
há funções que permitem arredondar o resultado da operacção para cima ou para baixo dependendo
da finalidade da operação.
Vantagens de usar um tipo ou outro tipo
Quanto menor o tipo mais rápido, simples e eficiente será a execução da operação, mas o risco de
estouro é grande. Um tipo muito grande de dado numérico exige que a operação seja feita no núcleo
matemático do processador ( acredite ou não mas antigamente era um chip separado do processador
chamado co-processador aritimético ). Contudo, mesmo assim representa um custo maior que um tipo
menor de dado.
Limite das Variáveis ASP NET
| Nome do tipo .NET |
Nome no VB |
Nome no C# |
Range |
| Byte |
Byte |
byte |
Armazena números Inteiros de 0 a 255, um byte sem sinal. |
| Int16 |
Short |
short |
Armazena números Inteiros de −32.768 a 32.767 - 15 bits + 1 de sinal |
| Int32 |
Integer |
int |
Armazena números Inteiros de −2.147.483.648 a 2.147.483.647 |
| Int64 |
Long |
long |
Armazena números Inteiros de −9.2E18 a 9.2E18 (Valor aproximado) |
| Single |
Single |
float |
É um tipo chamado Ponto flutuante de precisão simples e pode armazenar de −3.4e38 a
3.4E38 (para números grandes) ou −1.5E-45 a 1.5E-45 (para números fracionários pequenos-aproximado).
(*3)
|
| Double |
Double |
double |
Chamado de Ponto flutuante de precisão dupla pode armazenar de −1.8E308 a 1.8E308
(para numeros grandes) ou −5.0E-324 a 5.0E-324 (para números fracionários pequenos-aproximado).
(*3)
|
| Decimal |
Decimal |
decimal |
Armazena Números inteiros com 128 bits ou 16 bytes e representam uma potência de 10. Podemos armazenar
um número nos limites de +/-79.228.162.514.264.337.593,543.950.335 ou
+/-7.9228162514264337593543950335E+28. (*3)
|
| Char |
Char |
char |
Um caractere (*4) Unicode (*2). Ocupa 2 bytes ou 16 bits |
| String |
String |
string |
Uma variável de tamanho variável que contém um conjunto de caracteres (*4) Unicode (*2) |
| Boolean |
Boolean |
bool |
Armazena um valor binário (*5) verdadeiro(True) ou falso(False) |
| DateTime |
Date |
(*1) |
Representa uma data e horário (*6) de 12:00:00 AM de Janeiro do ano 1 no calendário Gregoriano,
até 31 de Dezembro de 9999 às 11:59:59 PM. Os valores de tempo são medidos em 100 de nano-segundos.
Internamente, este tipo de dado é armazendo como um inteiro de 64 bits.
|
| TimeSpan |
(*1) |
(*1) |
Representa o período de tempo com um número inteiro, como 10 segundos ou 3 dias mas contando
1 a cada 100 nanosegundos passados.
O menor valor possível é 1 tick (100 nanosegundos) mas nada que você irá processar usará faixas
tão pequenas de tempo da ordem de nanosegundos. É usado para calculo do período de tempo com
grande precisão.
|
| Object |
Object |
object |
Pode conter qualquer tipo de objeto do .NET. Por exemplo, um array ou uma structure
é um objeto complexo do .NET que foi adaptado/criado para representar variáveis de qualquer
espécie que o usuário possa precisar ou criar.
Digamos que o tipo coringa de dados, pode armazenar qualquer coisa dentro do .NET mas é
diferente do tipo Variant de antigamente ou do Excel por exemplo. O objeto é sempre uma
estrutura que armazena valores / dados, propriedades, características, etc.
|
| Notas: |
|
*1 - A linguagem não tem um alias para este tipo de variável (timespan).
Por esse motivo usamos o termo timespan nativo .NET para este tipo de variável.
|
|
*2 - Um caractere UNICODE ocupa 2 bytes de memória e com isso conseguimos representar
praticamente qualquer caractere de qualquer idioma com este tipo de dados. É o companheiro
ideal para o Unicode - UTF-8.
|
|
*3 - Este é um tipo de dados que podemos chamar de 'astronomico' e não deve ser usado para
armazenar dinheiro porque há erros de arredondamento nas operações. Um erro de 1 metro um ano luz
não é significativo mas um centavo numa soma de 100 itens pode causar uma briga.
|
|
*4 - Um caractere pode ser uma letra ou um número ou um símbolo em qualquer idioma.
|
|
*5 - Binário é um tipo de variável de um bit que armazena dois valores possíveis 0 ou 1 e em
implementações do C ou C++ isto é verdade, mas no .NET a variável binária ocupa um byte ( 8 bits )
e é associada aos valores falso ou verdadeiro.
|
|
*6 - A Data é uma das maldições do SQL ou .NET. Apesar do valor ser armazenado sempre da mesma
maneira na memória, banco de dados, etc a sua exibição depende do idioma escolhido ara exibir a
data. Sendo assim se for Brasil seria DD/MM/YYYY mas se fosse americano/inglês seria
MM/DD/AAAA e se fosse universal seria YYYY-MM-DD. Não se esqueça que, por exemplo, o ano no Japão
é contado a partir da posse do imperador, nos paises muçulmanos e orientais não usam o calendário
Juliano e, sendo assim, o dia x aqui tem que ser convertido no dia y do ano de lá.
|
Uma visão mais detalhada das variáveis
| Tipo Variável VB |
Tipo na Common language runtime |
Tipo no VB |
Alocação / Uso da memória |
Range de Valores |
| Boolean |
Boolean |
Logica |
Depende da plataforma que foi implementada. Mais comum 1 byte. |
Verdadeiro(True) ou False(false) |
| Byte |
Byte |
Numerica Inteiro |
1 byte |
de 0 atpe 255 (sem sinal) |
| Byte com sinal |
SByte |
Numerica Inteira |
1 byte |
de -128 a +127 |
| Char(caractere simples) |
Char |
Char |
2 bytes |
de 0 até 65535 (sem sinal) |
| Data |
DateTime |
Datetime |
8 bytes |
0:00:00 (meia noite) de Primeiro de Janeiro de 0001 até 23:59:59 de 31 de Dezember de 9999 |
| Decimal |
Decimal |
Numerico-Inteiro |
16 bytes |
0 a +/-79,228,162,514,264,337,593,543,950,335 (+/-7.9...E+28) sem o ponto decimal.
0 a +/-7.9228162514264337593543950335 com 28 casas de precisão;
O menor número acima de zero é +/- 0.0000000000000000000000000001 (+/-1E-28).
|
|
Double(Ponto Flutuante de dupla-precision)
|
Double |
Numerico |
8 bytes |
de -1.79769313486231570E+308 a -4.94065645841246544E-324 para valores negativos
de 4.94065645841246544E-324 a 1.79769313486231570E+308 para valores positivos.
|
| Integer |
Int32 |
Numeric |
4 bytes |
de -2,147,483,648 a 2,147,483,647 (com sinal) |
| Integer sem sinal |
UInteger |
Numeric |
4 bytes |
Núemros Positivos integer entre 0 to 4.294.967.295 |
| Long(inteiro long) |
Int64 |
Numerico inteiro |
8 bytes |
de -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 (9.2...E+18 †) (com sinal)
|
| Object |
Object (class) |
- |
4 bytes nas plataformas de 32-bit platform
8 bytes nas plataformas de 64-bits |
Qualquer tipo pode ser armazenado dentro de uma variável tipo Objeto |
| SByte - byte com sinal |
SByte |
Numeric |
1 byte |
de -128 a 127 (com sinal) |
| Short(inteiro curto) |
Int16 |
Numerica inteira |
2 bytes |
de -32,768 a 32,767 (com sinal) |
| Inteiro curto sem sinal |
UShort |
Numerica inteira |
2 bytes |
Representa um número Positivo intero de 0 to 65.535 |
|
Single(Ponto Flutuante de simples-precisão)
|
Single |
Numerica |
4 bytes |
de -3.4028235E+38 a -1.401298E-45 † para valores negativos
de 1.401298E-45 through 3.4028235E+38 para valores positivos.
|
|
String(variável de tamanho variável)
|
String (class) |
String |
Dependes da implementação na platforma |
0 até aproximadamente 2 bilhões de caracteres Unicode (*7) |
| UInteger-Inteiro sem sinal |
UInt32 |
Numerica inteiro |
4 bytes |
de 0 a 4,294,967,295 (sem sinal) |
| ULong-Longo sem sinal |
UInt64 |
Numerica inteira |
8 bytes |
de 0 a 18,446,744,073,709,551,615 (1.8...E+19 ) (sem sinal) |
| User-Defined (estrutura) |
(inherits from ValueType) |
- |
Depende da implementação na plataforma |
Cada membro da estrutura tem um faixa de valores determinada pelo seu tipo primitivo
independentemente de quantos itens sejam.
|
| UShort - Inteiro curto sem sinal |
UInt16 |
Numeric |
2 bytes |
de 0 a65,535 (sem sinal) |
| Notas: |
As variáveis numéricas com o simbolo E em sua faixa de valores foram
escritas no formato de notação cientifica e "E" refere-se a potência de 10.
Portantoo 3.56E+2 significa 3.56 x 102 ou 356 , e 3.56E-2 significa 3.56 / 102
ou 0,0356.
|
Caracteres que definem os tipos das variáveis ( uso antigo )
| Caractere de tipo |
Descrição( Converte o valor para ) |
Exemplo |
| C |
Char |
Dim ch As String = "A"C |
| D or @ |
Decimal |
Dim price As Decimal = 12.99D |
| R or # |
Double |
Dim pi As Double = 3.14R |
| I or % |
Integer |
Dim count As Integer = 99I |
| L or & |
Long |
Dim distance As Long = 1999L |
| S |
Short |
Dim age As Short = 15 |
| F or ! |
Single |
Dim velocity As Single = 74.99F |
Tipos Complexos
Classes: Este é o tipo mais comum no .NET Framework. Strings e arrays são
dois exemplos de classes .NET, embora você possa facilmente criar seu próprio.
Structures ou estruturas : Estruturas, como classes, podem incluir campos, propriedades, métodos e eventos.
Ao contrário das classes, eles são tipos de valor, o que altera a maneira como eles se comportam
com a atribuição e operações de comparação. As estruturas também carecem de algumas das classes
mais avançadas características (como herança) e são geralmente mais simples e menores. inteiros, datas,
e personagens são todas estruturas.
Enumerations ou enumeradores : Uma enumeração define um conjunto de constantes inteiras que
identificam uma sequencia com nomes, um alias para os nomes.
Delegates: O delegade é um ponteiro de método que permite invocar um método
indiretamente. Os delegades são a base para a manipulação de eventos .NET.
Interfaces ou interface : Eles definem um escopo de um objeto ( como parâmetros )
mas ao invés de definir o elemento eles informam que são externos, que serão definidos mais
tarde por outro elemento na fase de compilação do progrma.
|
Common Reference and Value Types
|
| Data Type |
Nature |
Behavior |
| Int32,Decimal, Single, Double, and all other basic numeric types |
Value Type |
Equality and assignment operations work with the variable contents, not a reference. |
| DateTime, TimeSpan |
Value Type |
Equality and assignment operations work with the variable contents, not a reference. |
| Char, Byte, and Boolean |
Value Type |
Equality and assignment operations work with the variable contents, not a reference. |
| String |
Reference Type |
Equality and assignment operations appear to work with the variable contents, not a reference. |
| Array |
Reference Type |
Equality and assignment operations work with the reference, not the contents. |